/**
 *                            License
 * THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS  
 * CREATIVE COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). 
 * THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW.  
 * ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR  
 * COPYRIGHT LAW IS PROHIBITED.
 * 
 * BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND  
 * AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE  
 * MAY BE CONSIDERED TO BE A CONTRACT,
 * THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED 
 * HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.
 * 
 */
package lineage.model;

import java.util.List;

import lineage.controller.pc.L1PcController;
import lineage.model.gameworld.L1World;
import lineage.model.instance.L1PcInstance;
import lineage.packet.L1AbstractPacketServer;
import lineage.packet.server.S_MovePacket;
import lineage.util.RangeInt;
import lineage.util.collections.Lists;

/**
 * 玩家与NPC(有生命)共同的父类.
 * 
 * @version 2014年3月17日下午10:24:13
 * @author jrwz
 */
public abstract class L1Character extends L1Object {
    private static final long serialVersionUID = 2000251889441582194L;
    /** ‘已认识对象’列表. */
    private final List<L1Object> knownObjects = Lists.newCopyOnWriteArrayList();
    /** ‘已认识角色’列表. */
    private final List<L1PcInstance> knownPlayer = Lists.newCopyOnWriteArrayList();
    /** 对象的当前血量. */
    protected int hp;
    /** 对象的当前魔量. */
    protected int mp;
    /** 对象的最高血量. */
    protected int maxHP;
    /** 对象的最高魔量. */
    protected int maxMP;
    /** 对象的级别. */
    protected int level;
    /** 对象的物理防御. */
    private int ac;
    /** 对象的魔法防御. */
    private int mr;
    /** 对象的物理攻击力. */
    private int ap;
    /** 对象的魔法攻击力. */
    private int sp;
    /** 对象的物理伤害力. */
    private int ad;
    /** 对象的魔法伤害力. */
    private int sd;
    /** 对象的力量值. */
    private int str;
    /** 对象的体质值. */
    private int con;
    /** 对象的敏捷值. */
    private int dex;
    /** 对象的精神值. */
    private int wis;
    /** 对象的智力值. */
    private int _int;
    /** 对象的魅力值. */
    private int cha;
    /** 对象的经验值. */
    private long exp;
    /** 对象的正义值. */
    private int lawful;
    /** 对象的饱食度. */
    private int food;
    /** 对象的负重程度. */
    private int weight;
    /** 对象的火属性. */
    private int fire;
    /** 对象的水属性. */
    private int water;
    /** 对象的风属性. */
    private int wind;
    /** 对象的地属性. */
    private int earth;
    /** 对象的封号. */
    private String title;
    /** 对象的状态(0:NPC,道具、1:中毒 、2:隐身、4:PC、8:诅咒、16:勇水、128:幽灵状态). */
    private int status;
    /** 对象的亮度(照明范围). */
    private int light;
    /** 移动速度：(0.正常 1.加速 2.缓速). */
    private int speed;
    /** 对象的动作. */
    private int action;
    /** 对象的主人名称. */
    private String masterName;
    /** 对象是否在水下. */
    private boolean isUnderwater;
    /** 对象的中毒类型. */
    private int poisonType;

    /**
     * 当有对象进入自己屏幕范围时调用.
     * 
     * @param object
     *            - 目标对象
     */
    public void toPerceive(final L1Object object) {
    }

    /**
     * 当开始攻击时调用.
     * 
     * @param object
     *            - 要攻击的对象
     */
    public void toAttack(final L1Object object) {
    }

    /**
     * 当受到伤害时调用.
     * 
     * @param object
     *            - 攻击自己的对象
     */
    public void toBeInjured(final L1Object object) {
    }

    /**
     * 当开始移动时调用.
     * 
     * @param x
     *            - x坐标
     * @param y
     *            - y坐标
     * @param heading
     *            - 面向
     * @return 如果移动成功则返回true
     */
    public boolean toMove(final int x, final int y, final int heading) {
        // 设置移动后坐标
        getLocation().set(x, y);
        setHeading(heading);
        getMap().setPassable(getLocation(), false); // 增加障碍(该坐标不准通过)
        sendPacketAllPc2(new S_MovePacket(this)); // 向屏幕内的所有可见角色发送‘移动封包’(不包括自己)
        return true;
    }

    /**
     * 当使用物品时调用.
     * 
     * @param itemId
     *            - 物品编号
     */
    public void toItem(final int itemId) {
    }

    /**
     * 当使用魔法时调用.
     * 
     * @param skillId
     *            - 技能编号
     */
    public void toMagic(final int skillId) {
    }

    /**
     * 当死亡时调用.
     * 
     * @param object
     *            - 让自己死亡的对象
     */
    public void toDead(final L1Object object) {
    }

    /**
     * 当从地面捡起物品时调用.
     * 
     * @param objId
     *            - 该物品的唯一编号
     */
    public void toPickup(final int objId) {
    }

    /**
     * 当丢弃物品至地面时调用.
     * 
     * @param itemId
     *            - 该物品的编号
     */
    public void toDiscard(final int itemId) {
    }

    /**
     * 发送封包：可见范围(屏幕)内的全部‘角色’(排除自身).
     * 
     * @param packet
     *            - 要发送的服务端封包
     */
    public void sendPacketAllPc2(final L1AbstractPacketServer packet) {
        L1World.getInstance().getVisiblePlayer(this).forEach(pc -> pc.sendPackets(packet));
    }

    /**
     * 将对象加入‘已认识对象’列表.
     * 
     * @param object
     *            - 要加入的对象
     */
    public void addKnownObject(final L1Object object) {
        if (!isKnownsObject(object)) {
            knownObjects.add(object);
        }
    }

    /**
     * 将对象移出‘已认识对象’列表.
     * 
     * @param object
     *            - 要移出的对象
     */
    public void removeKnownObject(final L1Object object) {
        knownObjects.remove(object);
    }

    /**
     * 将角色加入‘已认识角色’列表.
     * 
     * @param pc
     *            - 要加入的角色
     */
    public void addKnownPlayer(final L1PcInstance pc) {
        if (!isKnownsPlayer(pc)) {
            knownPlayer.add(pc);
        }
    }

    /**
     * 将角色移出‘已认识角色’列表.
     * 
     * @param pc
     *            - 要移出的角色
     */
    public void removeKnownPlayer(final L1PcInstance pc) {
        knownPlayer.remove(pc);
    }

    /**
     * 是否为已认识的对象.
     * 
     * @param object
     *            - 对象
     * @return 如果是则返回true
     */
    public boolean isKnownsObject(final L1Object object) {
        return knownObjects.contains(object);
    }

    /**
     * 是否为已认识的角色.
     * 
     * @param pc
     *            - 角色
     * @return 如果是则返回true
     */
    public boolean isKnownsPlayer(final L1PcInstance pc) {
        return knownPlayer.contains(pc);
    }

    /**
     * 取得全部‘已认识对象’列表.
     * 
     * @return 列表
     */
    public List<L1Object> getKnownObjects() {
        return knownObjects;
    }

    /**
     * 取得全部‘已认识角色’列表.
     * 
     * @return 列表
     */
    public List<L1PcInstance> getKnownPlayers() {
        return knownPlayer;
    }

    /**
     * 将对象加入‘已认识对象’与‘已认识角色’列表内.
     * 
     * @param object
     *            - 要增加的对象
     */
    public void addAllKnownObjects(final L1Object object) {
        addKnownObject(object);
        addKnownPlayer((L1PcInstance) object);
    }

    /**
     * 将对象移出‘已认识对象’与‘已认识角色’列表内.
     * 
     * @param object
     *            - 要移出的对象
     */
    public void removeAllKnownObjects(final L1Object object) {
        removeKnownObject(object);
        removeKnownPlayer((L1PcInstance) object);
    }

    /**
     * 清空‘已认识对象’列表.
     */
    public void removeKnownObjects() {
        knownObjects.clear();
    }

    /**
     * 清空‘已认识角色’列表.
     */
    public void removeKnownPlayer() {
        knownPlayer.clear();
    }

    /**
     * 删除全部已认识的对象.
     * <p>
     * 清空‘已认识对象’与‘已认识角色’列表
     */
    public void removeAllKnownObjects() {
        removeKnownObjects();
        removeKnownPlayer();
    }

    /**
     * 取得对象的当前血量.
     * 
     * @return 对象的当前血量值
     */
    public int getHp() {
        return hp;
    }

    /**
     * 设置对象的当前血量.
     * 
     * @param hp
     *            - 要设置的血量值
     */
    public void setHp(int hp) {
        this.hp = hp;
        this.hp = RangeInt.ensure(this.hp, 0, Integer.MAX_VALUE); // 最低0、最高2147483647
    }

    /**
     * 增加对象的当前血量.
     * 
     * @param hp
     *            - 要增加的血量值
     */
    public void addHp(int hp) {
        this.hp += hp;
        setHp(this.hp);
    }

    /**
     * 取得对象的当前魔量.
     * 
     * @return 对象的当前魔量值
     */
    public int getMp() {
        return mp;
    }

    /**
     * 设置对象的当前魔量.
     * 
     * @param mp
     *            - 要设置的魔量值
     */
    public void setMp(int mp) {
        this.mp = mp;
        this.mp = RangeInt.ensure(this.mp, 0, Integer.MAX_VALUE); // 最低0、最高2147483647
    }

    /**
     * 增加对象的当前魔量.
     * 
     * @param hp
     *            - 要增加的魔量值
     */
    public void addMp(int mp) {
        this.mp += mp;
        setMp(this.mp);
    }

    /**
     * 取得对象的最高血量.
     * 
     * @return 对象的最高血量值
     */
    public int getMaxHP() {
        return maxHP;
    }

    /**
     * 设置对象的最高血量.
     * 
     * @param maxHP
     *            - 要设置的血量值
     */
    public void setMaxHP(int maxHP) {
        this.maxHP = maxHP;
        this.maxHP = RangeInt.ensure(this.maxHP, 1, Integer.MAX_VALUE); // 最低1、最高2147483647
    }

    /**
     * 增加对象的最高血量.
     * 
     * @param maxHP
     *            - 要增加的血量值
     */
    public void addMaxHp(int maxHP) {
        this.maxHP += maxHP;
        setMaxHP(this.maxHP);
    }

    /**
     * 取得对象的最高魔量.
     * 
     * @return 对象的最高魔量值
     */
    public int getMaxMP() {
        return maxMP;
    }

    /**
     * 设置对象的最高魔量.
     * 
     * @param maxMP
     *            - 要设置的魔量值
     */
    public void setMaxMP(int maxMP) {
        this.maxMP = maxMP;
        this.maxMP = RangeInt.ensure(this.maxMP, 0, Integer.MAX_VALUE); // 最低0、最高2147483647
    }

    /**
     * 增加对象的最高魔量.
     * 
     * @param maxMP
     *            - 要增加的魔量值
     */
    public void addMaxMp(int maxMP) {
        this.maxMP += maxMP;
        setMaxMP(this.maxMP);
    }

    /**
     * 取得对象的级别.
     * 
     * @return 对象的级别
     */
    public int getLevel() {
        return level;
    }

    /**
     * 设置对象的级别.
     * 
     * @param level
     *            - 要设置的级别
     */
    public void setLevel(int level) {
        this.level = level;
        this.level = RangeInt.ensure(this.level, 1, Short.MAX_VALUE); // 最低1、最高32767
    }

    /**
     * 增加对象的级别.
     * 
     * @param level
     *            - 要增加的级别
     */
    public void addLevel(int level) {
        this.level += level;
        setLevel(this.level);
    }

    /**
     * 取得对象的物理防御.
     * 
     * @return 对象的物理防御值
     */
    public int getAc() {
        return ac;
    }

    /**
     * 设置对象的物理防御.
     * 
     * @param ac
     *            - 要设置的物理防御值
     */
    public void setAc(int ac) {
        this.ac = ac;
        this.ac = RangeInt.ensure(this.ac, -211, 44); // 最低-211、最高44
    }

    /**
     * 增加对象的物理防御.
     * 
     * @param ac
     *            - 要增加的物理防御值
     */
    public void addAc(int ac) {
        this.ac += ac;
        setAc(this.ac);
    }

    /**
     * 取得对象的魔法防御.
     * 
     * @return 对象的魔法防御值
     */
    public int getMr() {
        return mr;
    }

    /**
     * 设置对象的魔法防御.
     * 
     * @param mr
     *            - 要设置的魔法防御值
     */
    public void setMr(int mr) {
        this.mr = mr;
        this.mr = RangeInt.ensure(this.mr, 0, 250); // 最低0、最高250
    }

    /**
     * 增加对象的魔法防御.
     * 
     * @param mr
     *            - 要增加的魔法防御值
     */
    public void addMr(int mr) {
        this.mr += mr;
        setMr(this.mr);
    }

    /**
     * 取得对象的物理攻击力.
     * 
     * @return 对象的物理攻击力值
     */
    public int getAp() {
        return ap;
    }

    /**
     * 设置对象的物理攻击力.
     * 
     * @param ap
     *            - 要设置的物理攻击力值
     */
    public void setAp(int ap) {
        this.ap = ap;
    }

    /**
     * 取得对象的魔法攻击力.
     * 
     * @return 对象的魔法攻击力值
     */
    public int getSp() {
        return sp;
    }

    /**
     * 设置对象的魔法攻击力.
     * 
     * @param sp
     *            - 要设置的魔法攻击力值
     */
    public void setSp(int sp) {
        this.sp = sp;
    }

    /**
     * 取得对象的物理伤害力.
     * 
     * @return 对象的物理伤害力值
     */
    public int getAd() {
        return ad;
    }

    /**
     * 设置对象的物理伤害力.
     * 
     * @param ad
     *            - 要设置的物理伤害力值
     */
    public void setAd(int ad) {
        this.ad = ad;
    }

    /**
     * 取得对象的魔法伤害力.
     * 
     * @return 对象的魔法伤害力值
     */
    public int getSd() {
        return sd;
    }

    /**
     * 设置对象的魔法伤害力.
     * 
     * @param sd
     *            - 要设置的魔法伤害力值
     */
    public void setSd(int sd) {
        this.sd = sd;
    }

    /**
     * 取得对象的力量值.
     * 
     * @return 对象的力量值
     */
    public int getStr() {
        return str;
    }

    /**
     * 设置对象的力量值.
     * 
     * @param str
     *            - 要设置的力量值
     */
    public void setStr(int str) {
        this.str = str;
        this.str = RangeInt.ensure(this.str, 0, 254); // 最低0、最高254
    }

    /**
     * 增加对象的力量值.
     * 
     * @param str
     *            - 要增加的力量值
     */
    public void addStr(int str) {
        this.str += str;
        setStr(this.str);
    }

    /**
     * 取得对象的体质值.
     * 
     * @return 对象的体质值
     */
    public int getCon() {
        return con;
    }

    /**
     * 设置对象的体质值.
     * 
     * @param con
     *            - 要设置的体质值
     */
    public void setCon(int con) {
        this.con = con;
        this.con = RangeInt.ensure(this.con, 0, 254); // 最低0、最高254
    }

    /**
     * 增加对象的体质值.
     * 
     * @param con
     *            - 要增加的体质值
     */
    public void addCon(int con) {
        this.con += con;
        setCon(this.con);
    }

    /**
     * 取得对象的敏捷值.
     * 
     * @return 对象的敏捷值
     */
    public int getDex() {
        return dex;
    }

    /**
     * 设置对象的敏捷值.
     * 
     * @param dex
     *            - 要设置的敏捷值
     */
    public void setDex(int dex) {
        this.dex = dex;
        this.dex = RangeInt.ensure(this.dex, 0, 254); // 最低0、最高254
    }

    /**
     * 增加对象的敏捷值.
     * 
     * @param dex
     *            - 要增加的敏捷值
     */
    public void addDex(int dex) {
        this.dex += dex;
        setDex(this.dex);
    }

    /**
     * 取得对象的精神值.
     * 
     * @return 对象的精神值
     */
    public int getWis() {
        return wis;
    }

    /**
     * 设置对象的精神值.
     * 
     * @param wis
     *            - 要设置的精神值
     */
    public void setWis(int wis) {
        this.wis = wis;
        this.wis = RangeInt.ensure(this.wis, 0, 254); // 最低0、最高254
    }

    /**
     * 增加对象的精神值.
     * 
     * @param wis
     *            - 要增加的精神值
     */
    public void addWis(int wis) {
        this.wis += wis;
        setWis(this.wis);
    }

    /**
     * 取得对象的智力值.
     * 
     * @return 对象的智力值
     */
    public int getInt() {
        return _int;
    }

    /**
     * 设置对象的智力值.
     * 
     * @param i
     *            - 要设置的智力值
     */
    public void setInt(int i) {
        _int = i;
        _int = RangeInt.ensure(_int, 0, 254); // 最低0、最高254
    }

    /**
     * 增加对象的智力值.
     * 
     * @param i
     *            - 要增加的智力值
     */
    public void addInt(int i) {
        _int += i;
        setInt(_int);
    }

    /**
     * 取得对象的魅力值.
     * 
     * @return 对象的魅力值
     */
    public int getCha() {
        return cha;
    }

    /**
     * 设置对象的魅力值.
     * 
     * @param cha
     *            - 要设置的魅力值
     */
    public void setCha(int cha) {
        this.cha = cha;
        this.cha = RangeInt.ensure(this.cha, 0, 254); // 最低0、最高254
    }

    /**
     * 增加对象的魅力值.
     * 
     * @param cha
     *            - 要增加的魅力值
     */
    public void addCha(int cha) {
        this.cha += cha;
        setCha(this.cha);
    }

    /**
     * 取得对象的经验值.
     * 
     * @return 对象的经验值
     */
    public synchronized long getExp() {
        return exp;
    }

    /**
     * 设置对象的经验值.
     * 
     * @param exp
     *            - 要设置的经验值
     */
    public synchronized void setExp(long exp) {
        final long maxExp = L1PcController.getMaxExp();
        this.exp = exp;
        if (this.exp < 0L) {
            this.exp = 0L;
        } else if (this.exp > maxExp) {
            this.exp = maxExp;
        }
    }

    /**
     * 增加对象的经验值.
     * 
     * @param exp
     *            - 要增加的经验值
     */
    public synchronized void addExp(final long exp) {
        this.exp += exp;
        setExp(this.exp);
    }

    /**
     * 取得对象的正义值.
     * 
     * @return 对象的正义值
     */
    public int getLawful() {
        return lawful;
    }

    /**
     * 设置对象的正义值.
     * 
     * @param lawful
     *            - 要设置的正义值
     */
    public void setLawful(int lawful) {
        this.lawful = lawful;
        this.lawful = RangeInt.ensure(this.lawful, Short.MIN_VALUE, Short.MAX_VALUE); // 最低-32768、最高32767
    }

    /**
     * 增加对象的正义值.
     * 
     * @param lawful
     *            - 要增加的正义值
     */
    public synchronized void addLawful(final int lawful) {
        this.lawful += lawful;
        setLawful(this.lawful);
    }

    /**
     * 取得对象的饱食度.
     * 
     * @return 对象的饱食度值
     */
    public int getFood() {
        return food;
    }

    /**
     * 设置对象的饱食度.
     * 
     * @param food
     *            - 要设置的饱食度值
     */
    public void setFood(int food) {
        this.food = food;
    }

    /**
     * 取得对象的负重程度.
     * 
     * @return 对象的负重程度值
     */
    public int getWeight() {
        return weight;
    }

    /**
     * 设置对象的负重程度.
     * 
     * @param weight
     *            - 要设置的负重程度值
     */
    public void setWeight(int weight) {
        this.weight = weight;
    }

    /**
     * 取得对象的火属性.
     * 
     * @return 对象的火属性值
     */
    public int getFire() {
        return fire;
    }

    /**
     * 设置对象的火属性.
     * 
     * @param fire
     *            - 要设置的火属性值
     */
    public void setFire(int fire) {
        this.fire = fire;
        this.fire = RangeInt.ensure(this.fire, Byte.MIN_VALUE, Byte.MAX_VALUE); // 最低-128、最高127
    }

    /**
     * 增加对象的火属性.
     * 
     * @param fire
     *            - 要增加的火属性值
     */
    public void addFire(int fire) {
        this.fire += fire;
        setFire(this.fire);
    }

    /**
     * 取得对象的水属性.
     * 
     * @return 对象的水属性值
     */
    public int getWater() {
        return water;
    }

    /**
     * 设置对象的水属性.
     * 
     * @param water
     *            - 要设置的水属性值
     */
    public void setWater(int water) {
        this.water = water;
        this.water = RangeInt.ensure(this.water, Byte.MIN_VALUE, Byte.MAX_VALUE); // 最低-128、最高127
    }

    /**
     * 增加对象的水属性.
     * 
     * @param water
     *            - 要增加的水属性值
     */
    public void addWater(int water) {
        this.water += water;
        setWater(this.water);
    }

    /**
     * 取得对象的风属性.
     * 
     * @return 对象的风属性值
     */
    public int getWind() {
        return wind;
    }

    /**
     * 设置对象的风属性.
     * 
     * @param wind
     *            - 要设置的风属性值
     */
    public void setWind(int wind) {
        this.wind = wind;
        this.wind = RangeInt.ensure(this.wind, Byte.MIN_VALUE, Byte.MAX_VALUE); // 最低-128、最高127
    }

    /**
     * 增加对象的风属性.
     * 
     * @param wind
     *            - 要增加的风属性值
     */
    public void addWind(int wind) {
        this.wind += wind;
        setWind(this.wind);
    }

    /**
     * 取得对象的地属性.
     * 
     * @return 对象的地属性值
     */
    public int getEarth() {
        return earth;
    }

    /**
     * 设置对象的地属性.
     * 
     * @param earth
     *            - 要设置的地属性值
     */
    public void setEarth(int earth) {
        this.earth = earth;
        this.earth = RangeInt.ensure(this.earth, Byte.MIN_VALUE, Byte.MAX_VALUE); // 最低-128、最高127
    }

    /**
     * 增加对象的地属性.
     * 
     * @param earth
     *            - 要增加的地属性值
     */
    public void addEarth(int earth) {
        this.earth += earth;
        setEarth(this.earth);
    }

    /**
     * 取得对象的封号.
     * 
     * @return 对象的封号
     */
    public String getTitle() {
        return title;
    }

    /**
     * 设置对象的封号.
     * 
     * @param title
     *            - 要设置的封号
     */
    public void setTitle(String title) {
        this.title = title;
    }

    /**
     * 取得对象的状态.
     * 
     * @return 对象的状态(0:NPC,道具、1:中毒 、2:隐身、4:PC、8:诅咒、16:勇水、128:幽灵状态)
     */
    public int getStatus() {
        return status;
    }

    /**
     * 设置对象的状态.
     * 
     * @param status
     *            - 要设置的状态(0:NPC,道具、1:中毒 、2:隐身、4:PC、8:诅咒、16:勇水、128:幽灵状态)
     */
    public void setStatus(int status) {
        this.status = status;
    }

    /**
     * 取得对象的亮度(照明范围).
     * 
     * @return 对象的亮度(照明范围)
     */
    public int getLight() {
        return light;
    }

    /**
     * 设置对象的亮度(照明范围).
     * 
     * @param light
     *            - 要设置的亮度(照明范围)
     */
    public void setLight(int light) {
        this.light = light;
    }

    /**
     * 取得移动速度.
     * 
     * @return 移动速度：(0.正常 1.加速 2.缓速)
     */
    public int getSpeed() {
        return speed;
    }

    /**
     * 设置移动速度.
     * 
     * @param speed
     *            - 移动速度：(0.正常 1.加速 2.缓速)
     */
    public void setSpeed(int speed) {
        this.speed = speed;
    }

    /**
     * 取得对象的动作.
     * 
     * @return 对象的动作
     */
    public int getAction() {
        return action;
    }

    /**
     * 设置对象的动作.
     * 
     * @param action
     *            - 要设置的动作
     */
    public void setAction(int action) {
        this.action = action;
    }

    /**
     * 取得对象的主人名称.
     * 
     * @return 对象的主人名称
     */
    public String getMasterName() {
        return masterName;
    }

    /**
     * 设置对象的主人名称.
     * 
     * @param masterName
     *            - 要设置的主人名称
     */
    public void setMasterName(String masterName) {
        this.masterName = masterName;
    }

    /**
     * 该对象是否在水下.
     * 
     * @return 在则返回true
     */
    public boolean isUnderwater() {
        return isUnderwater;
    }

    /**
     * 设置对象：是否在水下.
     * 
     * @param isUnderwater
     *            - true：在水下、false：不在水下
     */
    public void setUnderwater(final boolean isUnderwater) {
        this.isUnderwater = isUnderwater;
    }

    /**
     * 取得对象的中毒类型.
     * 
     * @return 对象的中毒类型：0.没中毒、1.一般毒、2.木诅毒
     */
    public int getPoisonType() {
        return poisonType;
    }

    /**
     * 设置对象的中毒类型.
     * 
     * @param poisonType
     *            - 要设置的中毒类型：0.没中毒、1.一般毒、2.木诅毒
     */
    public void setPoisonType(final int poisonType) {
        this.poisonType = poisonType;
    }

    /**
     * 对象是否中毒.
     * 
     * @return 如果中毒则返回true
     */
    public boolean isPoison() {
        return poisonType != 0;
    }

    /**
     * 对象是否中了‘一般毒’.
     * 
     * @return 如果是则返回true
     */
    public boolean isPoisonGeneral() {
        return poisonType == 1;
    }

    /**
     * 对象是否中了‘木诅毒’.
     * 
     * @return 如果是则返回true
     */
    public boolean isPoisonMummy() {
        return poisonType == 2;
    }
}
